home *** CD-ROM | disk | FTP | other *** search
/ ADA Programming Guide / ADA Programming Guide.iso / ada_gwu / adalib.c < prev    next >
C/C++ Source or Header  |  1996-01-30  |  11KB  |  398 lines
  1. /*
  2.  * Copyright (C) 1985-1992  New York University
  3.  * 
  4.  * This file is part of the Ada/Ed-C system.  See the Ada/Ed README file for
  5.  * warranty (none) and distribution info and also the GNU General Public
  6.  * License for more details.
  7.  */
  8.  
  9. /* liblist.c: translation of code generator read.stl*/
  10.  
  11. #include <stdlib.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include "config.h"
  15. #include "segment.h"
  16. #include "slot.h"
  17. #include "ifile.h"
  18. #include "miscp.h"
  19. #include "libfp.h"
  20.  
  21. static void load_library();
  22. static void get_local_ref_maps(IFILE *, int);
  23. static long get_cde_slots(IFILE *);
  24. static void get_slot(IFILE *, char *);
  25. static char *convert_date(char *);
  26. static char *unit_name_name(char *);
  27. static int is_subunit(char *);
  28. static char *formatted_name(char *);
  29. static char *formatted_stub(char *);
  30.  
  31. IFILE *LIBFILE;
  32.  
  33. #ifdef IBM_PC
  34. /* on the PC, a chdir must be undone before program completes.
  35.  * changed_dir is set when directory changed.
  36.  */
  37. #endif
  38.  
  39. void main(int argc, char **argv)
  40. {
  41.         int  c;
  42.         int  lib_opt = FALSE;
  43.         int  errflg = 0;
  44.  
  45.         extern int  optind;
  46.         extern char *optarg;
  47.     char *libname,*fname;
  48.     char *t_name;
  49.  
  50. #ifdef IBM_PC
  51.     fprintf(stderr, "NYU Ada/Ed Librarian Version 1.11.1\n");
  52.     fprintf(stderr, "Copyright (C) 1985-1992 by New York University.\n");
  53. #endif
  54.  
  55. #ifndef IBM_PC
  56.         while((c = getopt(argc,argv,"l:"))!=EOF) {
  57. #else
  58.         while((c = getopt(argc,argv,"L:l:"))!=EOF) {
  59.                 if (isupper(c)) c = tolower(c);
  60. #endif
  61.                 switch(c) {
  62.                 case 'l': /* specify library name */
  63.                         lib_opt = TRUE;
  64.                         libname = strjoin(optarg,"");
  65.                         break;
  66.                 case '?':
  67.                         errflg++;
  68.                 }        
  69.         }
  70.  
  71.     fname = (char *)0;
  72.     if (optind < argc) fname = argv[optind];
  73.         if (!lib_opt && fname == (char *)0) {
  74.         fname = getenv("ADALIB");
  75.         if (fname!= (char *)0) {
  76. #ifdef IBM_PC
  77.             fprintf(stderr, "L");
  78. #else
  79.             fprintf(stderr, "l");
  80. #endif
  81.             fprintf(stderr,"ibrary defined by ADALIB: %s\n", fname);
  82.         }
  83.     }
  84.     if ((!lib_opt && fname == (char *)0) || errflg) {
  85.         fprintf(stderr, "Usage: adalib [-l library]\n");
  86.         exit(1);
  87.     }
  88.         if (!lib_opt) {
  89.            libname = emalloc(strlen(fname) + 1);
  90.            strcpy(libname, fname);
  91.         }
  92.  
  93.     t_name = libset(libname);
  94.     LIBFILE = ifopen(LIBFILENAME, "", "r", 0);
  95.  
  96.     load_library();
  97.     exit(0);
  98. }
  99.  
  100. static void load_library()                                /*;load_library*/
  101. {
  102.     /*
  103.      * retrieve information from LIBFILE
  104.      * Called only if lib_option and not newlib.
  105.      */
  106.  
  107.     int        i, j, n, m, unumber, nodes, symbols;
  108.     int        comp_status, unit_count, cur_level;
  109.     char    *comp_date, *status_str, *uname, *aisname, *tmp_str;
  110.     char    *main_string;
  111.     int        is_main, empty_unit_slots, parent;
  112.     int        ignore;
  113.  
  114.  
  115.     unit_count = getnum(LIBFILE, "lib-unit-count");
  116.     n = getnum(LIBFILE, "lib-n");
  117.     empty_unit_slots = getnum(LIBFILE, "lib-empty-slots");
  118.     tmp_str = getstr(LIBFILE, "lib-tmp-str");
  119.     for (i = 1; i <= unit_count; i++) {
  120.         uname = getstr(LIBFILE, "lib-unit-name");
  121.         unumber = getnum(LIBFILE, "lib-unit-number");
  122.         aisname = getstr(LIBFILE, "lib-ais-name");
  123.         comp_date = getstr(LIBFILE, "unit-date");
  124.         symbols = getnum(LIBFILE, "lib-symbols");
  125.         nodes = getnum(LIBFILE, "lib-nodes");
  126.         is_main = getnum(LIBFILE, "lib-is-main");
  127.         if (is_main) {
  128.             if (streq(unit_name_type(uname), "ma"))
  129.                 main_string = "(Interface)";
  130.             else
  131.                 main_string = "  (Main)   ";
  132.         }
  133.         else {
  134.             main_string = "";
  135.         }
  136.         comp_status = getnum(LIBFILE, "lib-status");
  137.         status_str = (comp_status) ? "active  " : "obsolete";
  138.         printf("%8s %11s %-15s %s\n",
  139.             status_str, main_string, convert_date(comp_date),
  140.             formatted_name(uname));
  141.     }
  142.     printf("\n");
  143.     n = getnum(LIBFILE, "lib-n");
  144.     if (n) {
  145.         printf("stubs \n\n");
  146.         for (i = 1; i <= n; i++) {
  147.             uname = getstr(LIBFILE, "lib-unit-name");
  148.             aisname = getstr(LIBFILE, "lib-ais-name");
  149.             parent = getnum(LIBFILE, "lib-parent");
  150.             cur_level = getnum(LIBFILE, "lib-cur-level");
  151.             m = getnum(LIBFILE, "stub-file-size");
  152.             for (j = 1; j <= m; j++)
  153.                 ignore = getnum(LIBFILE, "stub-file");
  154.             printf("%s\n", formatted_stub(uname));
  155.         }
  156.         printf("\n");
  157.     }
  158. #ifdef TBSL
  159.     n = getnum(LIBFILE, "precedes-map-size");
  160.     printf("precedes map\n");
  161.     for (i = 1; i <= n; i += 2) {
  162.         dom = getnum(LIBFILE, "precedes-map-dom");
  163.         m = getnum(LIBFILE, "precedes-map-nelt");
  164.         printf("  %4d:", dom);
  165.         for (j = 1; j <= m; j++) {
  166.             range = getnum(LIBFILE, "precedes-map-ent");
  167.             printf(" %4d", range);
  168.         }
  169.         printf("\n");
  170.     }
  171.     n = getnum(LIBFILE, "compilation_table_size");
  172.     if (n) {
  173.         printf("\ncompilation table\n");
  174.         for (i = 1; i <= n; i++) {
  175.             unum = (int) getnum(LIBFILE, "compilation-table-ent");
  176.             printf("  %d\n", unum);
  177.         }
  178.         printf("\n");
  179.     }
  180.     /* late_instances */
  181.     n = getnum(LIBFILE, "late-instances-size");
  182.     if (n) {
  183.         printf("late instances\n");
  184.         for (i = 1; i <= n; i++) {
  185.             str = (char *) getstr(LIBFILE, "late-instances-str");
  186.             printf("  %s\n", str);
  187.         }
  188.     }
  189.     /* current code segment */
  190.     n = getnum(LIBFILE, "unit-size");
  191.     printf("\ncurrent code segments\n");
  192.     printf("  unit cs\n");
  193.     for (i = 1; i <= n; i++) {
  194.         cs = getnum(LIBFILE, "current-code-segment");
  195.         if (cs) printf("   %d: %d\n", i, cs);
  196.     }
  197.     /* local reference maps */
  198.     n = getnum(LIBFILE, "unit-size");
  199.     get_local_ref_maps(LIBFILE, n);
  200.     cde_pos = get_cde_slots(LIBFILE, axq);
  201.  
  202.  
  203.     /* could free axq_data_slots, etc., but keep for now */
  204.     /* read out LIB_STUB map (always empty for now) */
  205.     ifclose(LIBFILE);
  206.     return;
  207. #endif
  208. /*
  209.     n = getnum(LIBFILE, "unit-size");
  210.     get_local_ref_maps(LIBFILE, n);
  211. */
  212.      get_cde_slots(LIBFILE);
  213.     ifclose(LIBFILE);
  214.     return;
  215. }
  216.  
  217. static void get_local_ref_maps(IFILE *ifile, int units)    /*;get_local_ref_map*/
  218. {
  219.     int        unit, defined, i, off, n;
  220.     int        sym_seq, sym_unit;
  221.  
  222.     printf("\nlocal reference maps\n");
  223.     for (unit = 1; unit <= units; unit++) {
  224.         /* ignore empty ref maps (predef units) and obselete units */
  225.         defined = getnum(ifile, "local-ref-map-defined");
  226.         if (!defined) continue;
  227.         printf("%d: ", unit);
  228.         n = getnum(ifile, "local-ref-map-size");
  229.         n = n/2;
  230.         for (i = 1; i <= n; i++) {
  231.             sym_seq = getnum(ifile, "local-ref-map-sym-seq");
  232.             sym_unit = getnum(ifile, "local-ref-map-sym-unit");
  233.             off = getnum(ifile, "local-ref-map-off");
  234.             /* if all three values are zero ignore this entry. It is a fake
  235.              * entry created by put_local_ref_map. see comment there.
  236.              */
  237.             if (sym_seq == 0 && sym_unit == 0 && off == 0) continue;
  238.             printf("%d %d %d ", sym_seq, sym_unit, off);
  239.         }
  240.         printf("\n");
  241.     }
  242.     printf("\n");
  243. }
  244.  
  245. static long get_cde_slots(IFILE *file)                /*;get_cde_slots*/
  246. {
  247.     long    dpos;
  248.     int        n_code, n_data, n_exception;
  249.  
  250.  
  251.     printf( "in get_cde_slots\n" );
  252.     dpos = file->fh_slots;
  253.     /* position to start of slot info */
  254.     ifseek(file, "get-cde-slots-start", dpos, 0);
  255.     n_code = getnum(file, "n-code");
  256.     n_data = getnum(file, "n-data");
  257.     n_exception = getnum(file, "n-exception");
  258.     get_slot(file, "code");
  259.     get_slot(file, "data");
  260.     get_slot(file, "exceptions");
  261.     return dpos; /* return offset of start of slot info */
  262. }
  263.  
  264. static void get_slot(IFILE *file, char *name)                    /*;get_slot*/
  265. {
  266.     /* This procedure reads in the SLOTS information. 
  267.      * Entries are Slots structures. nmax is guess at needed dimension,
  268.      * dim is set to dimension actually found.
  269.      */
  270.  
  271.     int i, n, exists;
  272.     int    slot_seq, slot_unit, slot_number;
  273. #ifdef MONITOR
  274.     char *slot_name, *slot_file, *slot_package;
  275. #endif
  276.  
  277.     n = getnum(file, "slot-entries");
  278.     printf("%s slots \n", name);
  279.     printf("  num seq unit  name                             package\n");
  280.  
  281.     for (i = 1; i <= n; i++) {
  282.         exists = getnum(LIBFILE, "slot-exists");
  283.         if (exists) {
  284.             slot_seq = getnum(LIBFILE, "slot-seq");
  285.             slot_unit = getnum(LIBFILE, "slot-unit");
  286.             slot_number = getnum(LIBFILE, "slot-number");
  287. #ifdef MONITOR
  288.             slot_name = getstr(LIBFILE, "slot_name");
  289.             slot_file = getstr(LIBFILE, "slot_file");
  290.             slot_package = getstr(LIBFILE, "slot_package");
  291.             printf("  %3d %3d %4d  %-32.32s %s\n",
  292.                 slot_number, slot_seq, slot_unit, slot_name,
  293.                 slot_package);
  294. #else
  295.             printf("  %3d %3d %4d \n",
  296.                 slot_number, slot_seq, slot_unit );
  297. #endif
  298.         }
  299.     }
  300.     printf("\n");
  301. }
  302.  
  303. static char *convert_date(char *comp_date)                    /*;convert_date*/
  304. {
  305.     static char new_date[15];
  306.     int    i;
  307.  
  308.     if (comp_date == (char *)0)
  309.         return(" ");
  310.     comp_date++;
  311.     comp_date++;
  312.     for (i = 6; i < 8; i++)
  313.         new_date[i] = *comp_date++;
  314.     comp_date++;
  315.     for (i = 0; i < 2; i++)
  316.         new_date[i] = *comp_date++;
  317.     new_date[2] = '/';
  318.     comp_date++;
  319.     for (i = 3; i < 5; i++)
  320.         new_date[i] = *comp_date++;
  321.     new_date[5] = '/';
  322.     new_date[8] = ' ';
  323.     comp_date++;
  324.     for (i = 9; i < 14; i++)
  325.         new_date[i] = *comp_date++;
  326.     new_date[11] = ':';
  327.  
  328.     new_date[14] = '\0';
  329.     return new_date;
  330. }
  331.  
  332. static char *unit_name_name(char *u)                        /*;unit_name_name*/
  333. {
  334.     int    n;
  335.     char    *s1, *s2;
  336.  
  337.     n = strlen(u);
  338.     if (n <= 2)
  339.         return (char *)0;
  340.  
  341.     s1 = u+2;                 /* point to start of name*/
  342.     s2 = strchr(s1, '.');     /* look for dot after first name */
  343.     if (s2 == (char *)0)     /* if no dot take rest of string */
  344.         s2 = u + n;         /* find end */
  345.     n = s2 - s1;
  346.     s2 = emalloc((unsigned) n+1);
  347.     strncpy(s2, s1, n);
  348.     s2[n] = '\0'; /* terminate result */
  349.     return (s2);
  350. }
  351.  
  352. static int is_subunit(char *u)                                    /*;is_subunit*/
  353. {
  354.     /* In C, IS_SUBUNIT is procedure is_subunit():
  355.      *    IS_SUBUNIT(na);           (#na > 2)                          endm;
  356.      */
  357.  
  358.     int    n;
  359.     char    *s1, *s2;
  360.  
  361.     if (u == (char *)0)
  362.         chaos("is_subunit: null pointer");
  363.     n = strlen(u);
  364.     if (n <= 2)
  365.         return FALSE;
  366.     s1 = u + 2; /* point to start of name*/
  367.     s2 = strchr(s1, '.'); /* look for dot after first name */
  368.     if (s2 == (char *)0) /* if no dot take rest of string */
  369.         return FALSE;
  370.     return TRUE; /* if subunit*/
  371. }
  372.  
  373. static char *formatted_name(char *unit)                    /*;formatted_name*/
  374. {
  375.     char *kind, *unit_kind;
  376.  
  377.     kind = unit_name_type(unit);
  378.     if (is_subunit(unit))        unit_kind = "proper body ";
  379.     else if (streq(kind, "sp"))  unit_kind = "package spec ";
  380.     else if (streq(kind, "bo"))  unit_kind = "package body ";
  381.     else if (streq(kind, "ss"))  unit_kind = "subprogram spec ";
  382.     else if (streq(kind, "su"))  unit_kind = "subprogram ";
  383.     else if (streq(kind, "ma"))  unit_kind = "binding unit ";
  384.     else unit_kind = "unit ";
  385.     return strjoin(unit_kind, unit_name_name(unit));
  386. }
  387.  
  388. static char *formatted_stub(char *unit)                        /*;formatted_stub*/
  389. {
  390.     char *kind, *unit_kind;
  391.  
  392.     kind = unit_name_type(unit);
  393.     if (streq(kind, "bo"))  unit_kind = "package (task) stub ";
  394.     else if (streq(kind, "su"))  unit_kind = "subprogram stub ";
  395.     else unit_kind = "stub ";
  396.     return strjoin(unit_kind, unit_name_name(unit));
  397. }
  398.